// 题意：给定一个1~n的房间，每次可以入住，需要开连续k个房间，返回最坐标可行的
//       房间号，如果没有就返回。也可以退房，将一个区间[l, r]的房间都退了，
//       无论是不是空的。
//
// 题解：线段树的做法很直观。维护一个co，0表示当前线段全空，1表示全有，-1
//       表示部分有，再维护 lmax：线段左边连续最大的空方间数，rmax：表示
//       线段右边连续的空房间数，max_len表示该线段中最大的连续空房间数。
//       这样就能维护出题目的信息了。
//
// opt: 0
// flag: -g
// run: $exec < input
#include <iostream>

struct node
{
	int l, r, rmax, lmax, max_len; // max continous empty
	int co; // 0: empty  1: full  -1: others
};

int const maxn = 500007;
node tree[4*maxn];
int n, m;

void init_seg_tree(int id, int l, int r)
{
	tree[id].l = l; tree[id].r = r;
	tree[id].co = 0;
	tree[id].lmax = tree[id].rmax = tree[id].max_len = r - l + 1;
	if (l == r) return;
	int mid = (l + r) / 2;
	init_seg_tree(id * 2, l, mid);
	init_seg_tree(id * 2 + 1, mid + 1, r);
}

void push_down(int id)
{
	tree[id * 2].co = tree[id * 2 + 1].co = tree[id].co;
	tree[id * 2].lmax = tree[id * 2].rmax = tree[id * 2].max_len
		= (tree[id].co ? 0 : tree[id * 2].r - tree[id * 2].l + 1);
	tree[id * 2 + 1].lmax = tree[id * 2 + 1].rmax = tree[id * 2 + 1].max_len
		= (tree[id].co ? 0 : tree[id * 2 + 1].r - tree[id * 2 + 1].l + 1);
	tree[id].co = -1;
}

void push_up(int id)
{
	tree[id].lmax = tree[id * 2].lmax;
	if (!tree[id * 2].co)
		tree[id].lmax += tree[id * 2 + 1].lmax;

	tree[id].rmax= tree[id * 2 + 1].rmax;
	if (!tree[id * 2 + 1].co)
		tree[id].rmax += tree[id * 2].rmax;

	tree[id].max_len = std::max(tree[id * 2].rmax + tree[id * 2 + 1].lmax,
				std::max(tree[id * 2].max_len, tree[id * 2 + 1].max_len));
	tree[id].max_len = std::max(tree[id].max_len,
				std::max(tree[id].lmax, tree[id].rmax));

	if (tree[id].max_len == tree[id].r - tree[id].l + 1)
		tree[id].co = 0;
	else
		tree[id].co = (tree[id].max_len ? -1 : 1);
}

int seg_query(int id, int len)
{
	if (tree[id].max_len < len) return 0;
	if (tree[id].lmax >= len) return tree[id].l;

	if (tree[id * 2].max_len >= len)
		return seg_query(id * 2, len);

	if (tree[id * 2].rmax + tree[id * 2 + 1].lmax >= len)
		return tree[id * 2].r - tree[id * 2].rmax + 1;

	return seg_query(id * 2 + 1, len);
}

void seg_update(int id, int l, int r, bool flag) // false: remove, true: add
{
	if (tree[id].l == l && tree[id].r == r) {
		tree[id].co = flag;
		tree[id].lmax = tree[id].rmax = tree[id].max_len = (flag ? 0 : r - l + 1);
		return;
	}

	if (tree[id].co != -1) push_down(id);

	int mid = (tree[id].l + tree[id].r) / 2;
	if (r <= mid)
		seg_update(id * 2, l, r, flag);
	else if (l > mid)
		seg_update(id * 2 + 1, l, r, flag);
	else {
		seg_update(id * 2, l, mid, flag);
		seg_update(id * 2 + 1, mid + 1, r, flag);
	}

	push_up(id);
}

int main()
{
	std::ios::sync_with_stdio(false);
	std::cin >> n >> m;
	init_seg_tree(1, 1, n);

	for (int i = 0, opt, x, y; i < m; i++) {
		std::cin >> opt;
		if (opt == 1) {
			std::cin >> x;
			int tid = seg_query(1, x);
			std::cout << tid << '\n';
			if (tid) seg_update(1, tid, tid + x - 1, true);
		} else {
			std::cin >> x >> y;
			seg_update(1, x, x + y - 1, false);
		}
	}
}

